//sort()方法用来排序的，排序结果是根据access码进行排序的
['yes','no','micstaat'].sort();
console.log(['yes','no','micstaat'].sort());

var asb=[10,30,2,3,7,1,99];
console.log(asb.sort());

var asb=['ASLK','appse','SALK'];
console.log(asb.sort());//小写的英文字母的ascll码在大写的后

var a1=[10,20,1,2];
a1.sort(function(x,y){
    if(x>y){
        return 1;
    }
    if(x<y){
        return -1;
    }
    return 0;
});
console.log(a1);//sort是一个高阶函数，可以自定义排序；
//tolowercase  把单词 小写 
//toUpperCase  把单词 大写
var a2=['Google', 'apple', 'Microsoft'];
a2.sort(function(s1,s2){
    x1=s1.toUpperCase();//小写
    x2=s2.toUpperCase();//大写
    if(x1>x2){
        return 1;
    }
    if(x1<x2){
        return -1;
    }
    return 0;
});
console.log(a2);


var a3=['Google', 'apple', 'Microsoft'];
console.log(a3);
console.log(a3.sort());//sort() 方法会直接对array进行修改，返回当前的array
console.log(a3);

//every()方法 用于测试判断所有字符串是否满足指定的测试条件：
var arr =['Apple', 'pear', 'orange'];
console.log(arr.every(function(s){
    return s.length >0;  //true
}));    
var aa =['Apple', 'pear', 'orange'];
console.log(aa.every(function(s){
    return s.toLowerCase()===s; //false
}));

//find()方法 用来找符合条件的元素，如果找到了返回，如果没找到返回undefined

var aad =['Apple', 'pear', 'orange','ASSST'];
console.log(aad.find(function(s){
    return s.toLowerCase()===s;  //pear
}));

///findindex 类似find() ,不同在于找到了返回索引，没找到返回-1
var ar2r = ['Apple', 'pear', 'orange'];
console.log(ar2r.findIndex(function(s){
    return s.toLowerCase()===s;
}));
var ar2r3 = ['aPple', 'pear', 'orange'];
console.log(ar2r3.findIndex(function(s){
    return s.toUpperCase()===s;
}));
//foreach 打印每个元素
var ar2r3 = ['aPple', 'pear', 'orange'];
ar2r3.forEach(console.log);

///函数返回值
function sum(a) {
    return a.reduce(function (x,y) {
        return x+y;
    });
    return sum;
}
console.log(sum([1,2,3,4,5]));//把函数作为返回值

function sum1(a2) {
    var qq=function () {
        return a2.reduce(function (x,y) {
            return x+y;
        });
    }
    return qq;
}
var f=sum1([1,2,3,4])
console.log(f());//调用sum1时不是调用结果，是调用函数
var f1=sum1([1,2,3]);
var f2=sum1([1,2,3]);
f1===f2;
console.log(f1());    //调用函数返回值时，即使结果相同也不相等，每次都会返回新的函数
console.log(f2());
console.log(f1===f2);

///闭包
function count() {
    var arr=[];
    for (var i = 1; i <=3; i++){
        arr.push(function () {///返回数组新的长度
            return i*i;
        });
    }
    return arr;
}
var results = count();
var f1 = results[0];
var f2 = results[1];
var f3 = results[2];

console.log(f1());////16
console.log(f2());////16
console.log(f3());///16
///闭包  返回函数不要引用任何循环变量函数 因为他不是立刻执行
//一定要引用循环可以用以下方法
function count1() {
    var arr = [];
    for (var i=1; i<=3; i++) {
        arr.push((function (n) {
            return function () {
                return n * n;
            }
        })(i));
    }
    return arr;
}
var results1 = count1();
var f1 = results1[0];
var f2 = results1[1];
var f3 = results1[2];
console.log(f1());////1
console.log(f2());////4
console.log(f3());///9

//立即执行函数
(function (x) {
    return x*x;
}(3));

//定义一个js 计时器
function aaat(inst) {
    var x=inst||0;
    return {
        inc:function () {
            x=x+1;
            return x;
        }
    }
}

var c1 = aaat();
console.log(c1.inc()); // 1
console.log(c1.inc()); // 2
console.log(c1.inc());// 3

var c2 = aaat(10);
console.log(c2.inc());// 11
console.log(c2.inc()); // 12
console.log(c2.inc());// 13
//闭包就是携带状态的函数，并且它的状态可以完全对外隐藏起来。

function aaad(n) {
    return function (x) {
        return Math.pow(x,n);
    }
}
var pow2=aaad(2);
console.log(pow2(2));
console.log(pow2(5));

var pow3=aaad(3);
console.log(pow3(5));
console.log(pow3(7));
console.log(pow3(2));